#!/usr/bin/env python
# -*- coding: utf-8 -*-

from flask import Blueprint, request, jsonify, g, current_app
from flask_jwt_extended import jwt_required, get_jwt_identity

from models import db, User, Role, Permission
from rbac import rbac_required, admin_required, permission_required, role_required

# 创建API蓝图
api_bp = Blueprint('api', __name__)


# 用户管理API
@api_bp.route('/users', methods=['GET'])
@jwt_required()
@rbac_required(resource='user', action='read')
def get_users():
    """获取所有用户列表（需要user:read权限）"""
    users = User.query.all()
    return jsonify({
        'status': 'success',
        'users': [user.to_dict() for user in users]
    }), 200


@api_bp.route('/users/<int:user_id>', methods=['GET'])
@jwt_required()
@rbac_required(resource='user', action='read')
def get_user(user_id):
    """获取指定用户信息（需要user:read权限）"""
    user = User.query.get_or_404(user_id)
    return jsonify({
        'status': 'success',
        'user': user.to_dict()
    }), 200


@api_bp.route('/users/<int:user_id>', methods=['PUT'])
@jwt_required()
@rbac_required(resource='user', action='update')
def update_user(user_id):
    """更新用户信息（需要user:update权限）"""
    user = User.query.get_or_404(user_id)
    data = request.get_json()
    
    # 只允许管理员或用户自己更新信息
    current_user = g.current_user
    if not current_user.has_role('admin') and current_user.id != user.id:
        return jsonify({
            'status': 'error',
            'message': '只能更新自己的信息或需要管理员权限'
        }), 403
    
    # 更新用户信息
    if 'email' in data:
        user.email = data['email']
    
    # 只有管理员可以更新用户状态
    if 'is_active' in data and current_user.has_role('admin'):
        user.is_active = data['is_active']
    
    # 更新密码
    if 'password' in data:
        user.set_password(data['password'])
    
    db.session.commit()
    
    return jsonify({
        'status': 'success',
        'message': '用户信息更新成功',
        'user': user.to_dict()
    }), 200


@api_bp.route('/users/<int:user_id>', methods=['DELETE'])
@jwt_required()
@admin_required
def delete_user(user_id):
    """删除用户（需要管理员权限）"""
    user = User.query.get_or_404(user_id)
    
    # 防止删除自己
    current_user = g.current_user
    if current_user.id == user.id:
        return jsonify({
            'status': 'error',
            'message': '不能删除自己的账号'
        }), 400
    
    db.session.delete(user)
    db.session.commit()
    
    return jsonify({
        'status': 'success',
        'message': f"用户 '{user.username}' 已被删除"
    }), 200


# 角色管理API
@api_bp.route('/roles', methods=['GET'])
@jwt_required()
@rbac_required(resource='role', action='read')
def get_roles():
    """获取所有角色列表（需要role:read权限）"""
    roles = Role.query.all()
    return jsonify({
        'status': 'success',
        'roles': [role.to_dict() for role in roles]
    }), 200


@api_bp.route('/roles', methods=['POST'])
@jwt_required()
@rbac_required(resource='role', action='create')
def create_role():
    """创建新角色（需要role:create权限）"""
    data = request.get_json()
    
    # 验证请求数据
    if 'name' not in data:
        return jsonify({
            'status': 'error',
            'message': '缺少必要的字段: name'
        }), 400
    
    # 检查角色名是否已存在
    if Role.query.filter_by(name=data['name']).first():
        return jsonify({
            'status': 'error',
            'message': f"角色名 '{data['name']}' 已存在"
        }), 409
    
    # 创建新角色
    role = Role(
        name=data['name'],
        description=data.get('description', '')
    )
    
    # 添加权限（如果提供）
    if 'permissions' in data and isinstance(data['permissions'], list):
        for perm_name in data['permissions']:
            perm = Permission.query.filter_by(name=perm_name).first()
            if perm:
                role.permissions.append(perm)
    
    db.session.add(role)
    db.session.commit()
    
    return jsonify({
        'status': 'success',
        'message': '角色创建成功',
        'role': role.to_dict()
    }), 201


@api_bp.route('/roles/<int:role_id>', methods=['PUT'])
@jwt_required()
@rbac_required(resource='role', action='update')
def update_role(role_id):
    """更新角色信息（需要role:update权限）"""
    role = Role.query.get_or_404(role_id)
    data = request.get_json()
    
    # 更新角色信息
    if 'name' in data:
        # 检查新角色名是否已存在
        existing_role = Role.query.filter_by(name=data['name']).first()
        if existing_role and existing_role.id != role.id:
            return jsonify({
                'status': 'error',
                'message': f"角色名 '{data['name']}' 已存在"
            }), 409
        role.name = data['name']
    
    if 'description' in data:
        role.description = data['description']
    
    # 更新权限
    if 'permissions' in data and isinstance(data['permissions'], list):
        # 清除现有权限
        role.permissions = []
        
        # 添加新权限
        for perm_name in data['permissions']:
            perm = Permission.query.filter_by(name=perm_name).first()
            if perm:
                role.permissions.append(perm)
    
    db.session.commit()
    
    return jsonify({
        'status': 'success',
        'message': '角色更新成功',
        'role': role.to_dict()
    }), 200


@api_bp.route('/roles/<int:role_id>', methods=['DELETE'])
@jwt_required()
@rbac_required(resource='role', action='delete')
def delete_role(role_id):
    """删除角色（需要role:delete权限）"""
    role = Role.query.get_or_404(role_id)
    
    # 防止删除基本角色
    if role.name in ['admin', 'user']:
        return jsonify({
            'status': 'error',
            'message': f"不能删除基本角色 '{role.name}'"
        }), 400
    
    db.session.delete(role)
    db.session.commit()
    
    return jsonify({
        'status': 'success',
        'message': f"角色 '{role.name}' 已被删除"
    }), 200


# 权限管理API
@api_bp.route('/permissions', methods=['GET'])
@jwt_required()
@rbac_required(resource='permission', action='read')
def get_permissions():
    """获取所有权限列表（需要permission:read权限）"""
    permissions = Permission.query.all()
    return jsonify({
        'status': 'success',
        'permissions': [perm.to_dict() for perm in permissions]
    }), 200


@api_bp.route('/permissions', methods=['POST'])
@jwt_required()
@rbac_required(resource='permission', action='create')
def create_permission():
    """创建新权限（需要permission:create权限）"""
    data = request.get_json()
    
    # 验证请求数据
    required_fields = ['name', 'resource', 'action']
    if not all(k in data for k in required_fields):
        return jsonify({
            'status': 'error',
            'message': f"缺少必要的字段: {', '.join(required_fields)}"
        }), 400
    
    # 检查权限名是否已存在
    if Permission.query.filter_by(name=data['name']).first():
        return jsonify({
            'status': 'error',
            'message': f"权限名 '{data['name']}' 已存在"
        }), 409
    
    # 创建新权限
    permission = Permission(
        name=data['name'],
        resource=data['resource'],
        action=data['action'],
        description=data.get('description', '')
    )
    
    db.session.add(permission)
    db.session.commit()
    
    return jsonify({
        'status': 'success',
        'message': '权限创建成功',
        'permission': permission.to_dict()
    }), 201


# 用户角色管理API
@api_bp.route('/users/<int:user_id>/roles', methods=['PUT'])
@jwt_required()
@admin_required
def update_user_roles(user_id):
    """更新用户角色（需要管理员权限）"""
    user = User.query.get_or_404(user_id)
    data = request.get_json()
    
    if 'roles' not in data or not isinstance(data['roles'], list):
        return jsonify({
            'status': 'error',
            'message': '缺少必要的字段: roles (数组)'
        }), 400
    
    # 清除现有角色
    user.roles = []
    
    # 添加新角色
    for role_name in data['roles']:
        role = Role.query.filter_by(name=role_name).first()
        if role:
            user.roles.append(role)
    
    db.session.commit()
    
    return jsonify({
        'status': 'success',
        'message': '用户角色更新成功',
        'user': user.to_dict()
    }), 200


# 测试不同权限级别的API
@api_bp.route('/test/public', methods=['GET'])
def test_public():
    """公开API，无需认证"""
    return jsonify({
        'status': 'success',
        'message': '这是一个公开的API，无需认证'
    }), 200


@api_bp.route('/test/authenticated', methods=['GET'])
@jwt_required()
def test_authenticated():
    """需要认证的API"""
    username = get_jwt_identity()
    return jsonify({
        'status': 'success',
        'message': f"你好，{username}！这是一个需要认证的API"
    }), 200


@api_bp.route('/test/admin', methods=['GET'])
@jwt_required()
@admin_required
def test_admin():
    """需要管理员权限的API"""
    username = g.current_user.username
    return jsonify({
        'status': 'success',
        'message': f"你好，管理员{username}！这是一个需要管理员权限的API"
    }), 200


@api_bp.route('/test/editor', methods=['GET'])
@jwt_required()
@role_required('editor')
def test_editor():
    """需要编辑者角色的API"""
    username = g.current_user.username
    return jsonify({
        'status': 'success',
        'message': f"你好，编辑者{username}！这是一个需要编辑者角色的API"
    }), 200


@api_bp.route('/test/permission', methods=['GET'])
@jwt_required()
@permission_required('content:publish')
def test_permission():
    """需要特定权限的API"""
    username = g.current_user.username
    return jsonify({
        'status': 'success',
        'message': f"你好，{username}！你有'content:publish'权限，可以访问此API"
    }), 200